home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gsfont.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-30  |  15.0 KB  |  520 lines
  1. /* Copyright (C) 1989, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsfont.c */
  20. /* Font operators for Ghostscript library */
  21. #include "gx.h"
  22. #include "memory_.h"
  23. #include "gserrors.h"
  24. #include "gsstruct.h"
  25. #include "gxfixed.h"
  26. #include "gxmatrix.h"
  27. #include "gzstate.h"            /* must precede gxdevice */
  28. #include "gxdevice.h"            /* must precede gxfont */
  29. #include "gschar.h"
  30. #include "gxfont.h"
  31. #include "gxfcache.h"
  32.  
  33. /* Imported procedures */
  34. void    gs_purge_font_from_char_caches(P2(gs_font_dir *, const gs_font *));
  35.  
  36. /* Define the sizes of the various aspects of the font/character cache. */
  37. /*** Big memory machines ***/
  38. #define smax_LARGE 50        /* smax - # of scaled fonts */
  39. #define bmax_LARGE 500000    /* bmax - space for cached chars */
  40. #define mmax_LARGE 200        /* mmax - # of cached font/matrix pairs */
  41. #define cmax_LARGE 5000        /* cmax - # of cached chars */
  42. #define blimit_LARGE 2500    /* blimit/upper - max size of a single cached char */
  43. /*** Small memory machines ***/
  44. #define smax_SMALL 20        /* smax - # of scaled fonts */
  45. #define bmax_SMALL 25000    /* bmax - space for cached chars */
  46. #define mmax_SMALL 40        /* mmax - # of cached font/matrix pairs */
  47. #define cmax_SMALL 500        /* cmax - # of cached chars */
  48. #define blimit_SMALL 100    /* blimit/upper - max size of a single cached char */
  49.  
  50. private_st_font_dir();
  51. private struct_proc_enum_ptrs(font_enum_ptrs);
  52. private struct_proc_reloc_ptrs(font_reloc_ptrs);
  53. public_st_gs_font();
  54. public_st_gs_font_base();
  55. private_st_gs_font_ptr();
  56. public_st_gs_font_ptr_element();
  57.  
  58. /*
  59.  * Garbage collection of fonts poses some special problems.  On the one
  60.  * hand, we need to keep track of all existing base (not scaled) fonts,
  61.  * using the next/prev list whose head is the orig_fonts member of the font
  62.  * directory; on the other hand, we want these to be "weak" pointers that
  63.  * don't keep fonts in existence if the fonts aren't referenced from
  64.  * anywhere else.  We accomplish this as follows:
  65.  *
  66.  *     We don't trace through gs_font_dir.orig_fonts or gs_font.{next,prev}
  67.  * during the mark phase of the GC.
  68.  *
  69.  *     When we finalize a base gs_font, we unlink it from the list.  (A
  70.  * gs_font is a base font iff its base member points to itself.)
  71.  *
  72.  *     We *do* relocate the orig_fonts and next/prev pointers during the
  73.  * relocation phase of the GC.  */
  74.  
  75. /* Font directory GC procedures */
  76. #define dir ((gs_font_dir *)vptr)
  77. private ENUM_PTRS_BEGIN(font_dir_enum_ptrs)
  78.     {    /* Enumerate pointers from cached characters to f/m pairs, */
  79.         /* and mark the cached character glyphs. */
  80.         /* See gxfcache.h for why we do this here. */
  81.         uint cci = index - st_font_dir_max_ptrs;
  82.         uint offset, count;
  83.         uint tmask = dir->ccache.table_mask;
  84.  
  85.         if ( cci == 0 )
  86.           offset = 0, count = 1;
  87.         else if ( cci == dir->enum_index + 1 )
  88.           offset = dir->enum_offset + 1, count = 1;
  89.         else
  90.           offset = 0, count = cci;
  91.         for ( ; offset <= tmask; ++offset )
  92.           {    cached_char *cc = dir->ccache.table[offset];
  93.             if ( cc != 0 && !--count )
  94.               { (*dir->ccache.mark_glyph)
  95.                   (cc->code, dir->ccache.mark_glyph_data);
  96.                 dir->enum_index = cci;
  97.                 dir->enum_offset = offset;
  98.                 ENUM_RETURN(cc_pair(cc) - cc->pair_index);
  99.               }
  100.           }
  101.     }
  102.     return 0;
  103. #define e1(i,elt) ENUM_PTR(i,gs_font_dir,elt);
  104.     font_dir_do_ptrs(e1)
  105. #undef e1
  106. ENUM_PTRS_END
  107. private RELOC_PTRS_BEGIN(font_dir_reloc_ptrs) ;
  108.     /* Relocate the pointers from cached characters to f/m pairs. */
  109.     /* See gxfcache.h for why we do this here. */
  110.     {    int chi;
  111.         for ( chi = dir->ccache.table_mask; chi >= 0; --chi )
  112.         {    cached_char *cc = dir->ccache.table[chi];
  113.             if ( cc != 0 )
  114.               cc_set_pair_only(cc,
  115.                 (cached_fm_pair *)
  116.                   gs_reloc_struct_ptr(cc_pair(cc) -
  117.                           cc->pair_index, gcst) +
  118.                        cc->pair_index);
  119.         }
  120.     }
  121.     /* We have to relocate the cached characters before we */
  122.     /* relocate dir->ccache.table! */
  123.     RELOC_PTR(gs_font_dir, orig_fonts);
  124. #define r1(i,elt) RELOC_PTR(gs_font_dir, elt);
  125.     font_dir_do_ptrs(r1)
  126. #undef r1
  127. RELOC_PTRS_END
  128. #undef dir
  129.  
  130. /* GC procedures for fonts */
  131. #define pfont ((gs_font *)vptr)
  132. /*
  133.  * When we finalize a base font, we unlink it from the orig_fonts list;
  134.  * when we finalize a scaled font, we unlink it from scaled_fonts.
  135.  * See above for more information.
  136.  */
  137. void
  138. gs_font_finalize(void *vptr)
  139. {    gs_font **ppfirst;
  140.     gs_font *next = pfont->next;
  141.     gs_font *prev = pfont->prev;
  142.  
  143.     if_debug4('u', "[u]unlinking font 0x%lx, base=0x%lx, prev=0x%lx, next=0x%lx\n",
  144.           (ulong)pfont, (ulong)pfont->base, (ulong)prev, (ulong)next);
  145.     if ( pfont->dir == 0 )
  146.       ppfirst = 0;
  147.     else if ( pfont->base == pfont )
  148.       ppfirst = &pfont->dir->orig_fonts;
  149.     else
  150.       { /*
  151.          * Track the number of cached scaled fonts.  Only decrement the
  152.          * count if we didn't do this already in gs_makefont.
  153.          */
  154.         if ( next || prev || pfont->dir->scaled_fonts == pfont )
  155.           pfont->dir->ssize--;
  156.         ppfirst = &pfont->dir->scaled_fonts;
  157.       }
  158.     /*
  159.      * gs_purge_font may have unlinked this font already:
  160.      * don't unlink it twice.
  161.      */
  162.     if ( next != 0 && next->prev == pfont )
  163.       next->prev = prev;
  164.     if ( prev != 0 )
  165.       { if ( prev->next == pfont )
  166.           prev->next = next;
  167.       }
  168.     else if ( ppfirst != 0 && *ppfirst == pfont )
  169.       *ppfirst = next;
  170. }
  171. private ENUM_PTRS_BEGIN(font_enum_ptrs) return 0;
  172.     /* We don't enumerate next or prev of base fonts. */
  173.     /* See above for details. */
  174.     case 0:
  175.       ENUM_RETURN((pfont->base == pfont ? 0 : pfont->next));
  176.     case 1:
  177.       ENUM_RETURN((pfont->base == pfont ? 0 : pfont->prev));
  178.     ENUM_PTR(2, gs_font, dir);
  179.     ENUM_PTR(3, gs_font, base);
  180.     ENUM_PTR(4, gs_font, client_data);
  181. ENUM_PTRS_END
  182. private RELOC_PTRS_BEGIN(font_reloc_ptrs) ;
  183.     /* We *do* always relocate next and prev. */
  184.     /* Again, see above for details. */
  185.     RELOC_PTR(gs_font, next);
  186.     RELOC_PTR(gs_font, prev);
  187.     RELOC_PTR(gs_font, dir);
  188.     RELOC_PTR(gs_font, base);
  189.     RELOC_PTR(gs_font, client_data);
  190. RELOC_PTRS_END
  191. #undef pfont
  192.  
  193. /* Allocate a font directory */
  194. private bool
  195. cc_no_mark_glyph(gs_glyph glyph, void *ignore_data)
  196. {    return false;
  197. }
  198. gs_font_dir *
  199. gs_font_dir_alloc(gs_memory_t *mem)
  200. {    gs_font_dir *pdir = 0;
  201. #if !arch_small_memory
  202. #  ifdef DEBUG
  203.     if ( !gs_debug_c('.') )
  204. #  endif
  205.       {    /* Try allocating a very large cache. */
  206.         /* If this fails, allocate a small one. */
  207.         pdir = gs_font_dir_alloc_limits(mem,
  208.                     smax_LARGE, bmax_LARGE, mmax_LARGE,
  209.                     cmax_LARGE, blimit_LARGE);
  210.       }
  211.     if ( pdir == 0 )
  212. #endif
  213.       pdir = gs_font_dir_alloc_limits(mem,
  214.                       smax_SMALL, bmax_SMALL, mmax_SMALL,
  215.                       cmax_SMALL, blimit_SMALL);
  216.     if ( pdir == 0 )
  217.       return 0;
  218.     pdir->ccache.mark_glyph = cc_no_mark_glyph;
  219.     pdir->ccache.mark_glyph_data = 0;
  220.     return pdir;
  221. }
  222. gs_font_dir *
  223. gs_font_dir_alloc_limits(gs_memory_t *mem,
  224.   uint smax, uint bmax, uint mmax, uint cmax, uint upper)
  225. {    register gs_font_dir *pdir =
  226.       gs_alloc_struct(mem, gs_font_dir, &st_font_dir,
  227.               "font_dir_alloc(dir)");
  228.     int code;
  229.     if ( pdir == 0 )
  230.       return 0;
  231.     code = gx_char_cache_alloc(mem, pdir, bmax, mmax, cmax, upper);
  232.     if ( code < 0 )
  233.     {    gs_free_object(mem, pdir, "font_dir_alloc(dir)");
  234.         return 0;
  235.     }
  236.     pdir->orig_fonts = 0;
  237.     pdir->scaled_fonts = 0;
  238.     pdir->ssize = 0;
  239.     pdir->smax = smax;
  240.     return pdir;
  241. }
  242.  
  243. /* Macro for linking an element at the head of a chain */
  244. #define link_first(first, elt)\
  245.   if ( (elt->next = first) != NULL ) first->prev = elt;\
  246.   elt->prev = 0;\
  247.   first = elt
  248.  
  249. /* definefont */
  250. /* Use this only for original (unscaled) fonts! */
  251. /* Note that it expects pfont->procs.define_font to be set already. */
  252. int
  253. gs_definefont(gs_font_dir *pdir, gs_font *pfont)
  254. {    int code;
  255.     pfont->dir = pdir;
  256.     pfont->base = pfont;
  257.     code = (*pfont->procs.define_font)(pdir, pfont);
  258.     if ( code < 0 )
  259.       { /* Make sure we don't try to finalize this font. */
  260.         pfont->base = 0;
  261.         return code;
  262.       }
  263.     link_first(pdir->orig_fonts, pfont);
  264.     if_debug2('m', "[m]defining font 0x%lx, next=0x%lx\n",
  265.           (ulong)pfont, (ulong)pfont->next);
  266.     return 0;
  267. }
  268. /* Default (vacuous) definefont handler. */
  269. int
  270. gs_no_define_font(gs_font_dir *pdir, gs_font *pfont)
  271. {    return 0;
  272. }
  273.  
  274. /* scalefont */
  275. int
  276. gs_scalefont(gs_font_dir *pdir, const gs_font *pfont, floatp scale,
  277.   gs_font **ppfont)
  278. {    gs_matrix mat;
  279.     gs_make_scaling(scale, scale, &mat);
  280.     return gs_makefont(pdir, pfont, &mat, ppfont);
  281. }
  282.  
  283. /* makefont */
  284. int
  285. gs_makefont(gs_font_dir *pdir, const gs_font *pfont,
  286.   const gs_matrix *pmat, gs_font **ppfont)
  287. {
  288. #define pbfont ((const gs_font_base *)pfont)
  289.     int code;
  290.     gs_font *prev = 0;
  291.     gs_font *pf_out = pdir->scaled_fonts;
  292.     gs_memory_t *mem = pfont->memory;
  293.     gs_matrix newmat;
  294.     bool can_cache;
  295.  
  296.     if ( (code = gs_matrix_multiply(&pfont->FontMatrix, pmat, &newmat)) < 0 )
  297.       return code;
  298.     /* Check for the font already being in the scaled font cache. */
  299.     /* Only attempt to share fonts if the current font has */
  300.     /* a valid UniqueID or XUID. */
  301. #ifdef DEBUG
  302. if ( gs_debug_c('m') )
  303.    {    if ( pfont->FontType == ft_composite )
  304.       dprintf("[m]composite");
  305.     else if ( uid_is_UniqueID(&pbfont->UID) )
  306.       dprintf1("[m]UniqueID=%ld", pbfont->UID.id);
  307.     else if ( uid_is_XUID(&pbfont->UID) )
  308.       dprintf1("[m]XUID(%u)", (uint)(-pbfont->UID.id));
  309.     else
  310.       dprintf("[m]no UID");
  311.     dprintf7(", FontType=%d,\n[m]  new FontMatrix=[%g %g %g %g %g %g]\n",
  312.       pfont->FontType,
  313.       pmat->xx, pmat->xy, pmat->yx, pmat->yy,
  314.       pmat->tx, pmat->ty);
  315.    }
  316. #endif
  317.     /* The UID of a composite font is of no value in caching.... */
  318.     if ( pfont->FontType != ft_composite &&
  319.          uid_is_valid(&pbfont->UID)
  320.        )
  321.     { for ( ; pf_out != 0; prev = pf_out, pf_out = pf_out->next )
  322.         if ( pf_out->FontType == pfont->FontType &&
  323.          pf_out->base == pfont->base &&
  324.          uid_equal(&((gs_font_base *)pf_out)->UID, &pbfont->UID) &&
  325.          pf_out->FontMatrix.xx == newmat.xx &&
  326.          pf_out->FontMatrix.xy == newmat.xy &&
  327.          pf_out->FontMatrix.yx == newmat.yx &&
  328.          pf_out->FontMatrix.yy == newmat.yy &&
  329.          pf_out->FontMatrix.tx == newmat.tx &&
  330.          pf_out->FontMatrix.ty == newmat.ty
  331.            )
  332.         {    *ppfont = pf_out;
  333.             if_debug1('m', "[m]found font=0x%lx\n", (ulong)pf_out);
  334.             return 0;
  335.         }
  336.       can_cache = true;
  337.     }
  338.     else
  339.       can_cache = false;
  340.     pf_out = gs_alloc_struct(mem, gs_font, gs_object_type(mem, pfont),
  341.                  "gs_makefont");
  342.     if ( !pf_out )
  343.         return_error(gs_error_VMerror);
  344.     memcpy(pf_out, pfont, gs_object_size(mem, pfont));
  345.     pf_out->FontMatrix = newmat;
  346.     pf_out->client_data = 0;
  347.     pf_out->dir = pdir;
  348.     pf_out->base = pfont->base;
  349.     *ppfont = pf_out;
  350.     code = (*pf_out->procs.make_font)(pdir, pfont, pmat, ppfont);
  351.     if ( code < 0 )
  352.         return code;
  353.     if ( can_cache )
  354.       {    if ( pdir->ssize >= pdir->smax && prev != 0 )
  355.         {    /*
  356.              * We must discard a cached scaled font.
  357.              * prev points to the last (oldest) font.
  358.              * (We can't free it, because there might be
  359.              * other references to it.)
  360.              */
  361.             if_debug1('m', "[m]discarding font 0x%lx\n",
  362.                   (ulong)prev);
  363.             if ( prev->prev != 0 )
  364.               prev->prev->next = 0;
  365.             else
  366.               pdir->scaled_fonts = 0;
  367.             pdir->ssize--;
  368.             prev->prev = 0;
  369.             if ( prev->FontType != ft_composite )
  370.             {    if_debug1('m', "[m]discarding UID 0x%lx\n",
  371.                       (ulong)((gs_font_base *)prev)->
  372.                                 UID.xvalues);
  373.                 uid_free(&((gs_font_base *)prev)->UID,
  374.                      prev->memory,
  375.                      "gs_makefont(discarding)");
  376.                 uid_set_invalid(&((gs_font_base *)prev)->UID);
  377.             }
  378.         }
  379.         pdir->ssize++;
  380.         link_first(pdir->scaled_fonts, pf_out);
  381.       }
  382.     else
  383.       { /* Prevent garbage pointers. */
  384.         pf_out->next = pf_out->prev = 0;
  385.       }
  386.     if_debug2('m', "[m]new font=0x%lx can_cache=%s\n",
  387.           (ulong)*ppfont, (can_cache ? "true" : "false"));
  388.     return 1;
  389. #undef pbfont
  390. }
  391. /* Default (vacuous) makefont handler. */
  392. int
  393. gs_no_make_font(gs_font_dir *pdir, const gs_font *pfont,
  394.   const gs_matrix *pmat, gs_font **ppfont)
  395. {    return 0;
  396. }
  397. /* Makefont handler for base fonts, which must copy the XUID. */
  398. int
  399. gs_base_make_font(gs_font_dir *pdir, const gs_font *pfont,
  400.   const gs_matrix *pmat, gs_font **ppfont)
  401. {
  402. #define pbfont ((gs_font_base *)*ppfont)
  403.     if ( uid_is_XUID(&pbfont->UID) )
  404.       {    uint xsize = uid_XUID_size(&pbfont->UID);
  405.         long *xvalues = (long *)
  406.           gs_alloc_byte_array(pbfont->memory, xsize, sizeof(long),
  407.                       "gs_base_make_font(XUID)");
  408.         if ( xvalues == 0 )
  409.           return_error(gs_error_VMerror);
  410.         memcpy(xvalues, uid_XUID_values(&pbfont->UID),
  411.                xsize * sizeof(long));
  412.         pbfont->UID.xvalues = xvalues;
  413.       }
  414. #undef pbfont
  415.     return 0;
  416. }
  417.  
  418. /* setfont */
  419. int
  420. gs_setfont(gs_state *pgs, gs_font *pfont)
  421. {    pgs->font = pgs->root_font = pfont;
  422.     pgs->char_tm_valid = false;
  423.     return 0;
  424. }
  425.  
  426. /* currentfont */
  427. gs_font *
  428. gs_currentfont(const gs_state *pgs)
  429. {    return pgs->font;
  430. }
  431.  
  432. /* rootfont */
  433. gs_font *
  434. gs_rootfont(const gs_state *pgs)
  435. {    return pgs->root_font;
  436. }
  437.  
  438. /* cachestatus */
  439. void
  440. gs_cachestatus(register const gs_font_dir *pdir, register uint pstat[7])
  441. {    pstat[0] = pdir->ccache.bsize;
  442.     pstat[1] = pdir->ccache.bmax;
  443.     pstat[2] = pdir->fmcache.msize;
  444.     pstat[3] = pdir->fmcache.mmax;
  445.     pstat[4] = pdir->ccache.csize;
  446.     pstat[5] = pdir->ccache.cmax;
  447.     pstat[6] = pdir->ccache.upper;
  448. }
  449.  
  450. /* setcacheparams */
  451. int
  452. gs_setcachesize(gs_font_dir *pdir, uint size)
  453. {    /* This doesn't delete anything from the cache yet. */
  454.     pdir->ccache.bmax = size;
  455.     return 0;
  456. }
  457. int
  458. gs_setcachelower(gs_font_dir *pdir, uint size)
  459. {    pdir->ccache.lower = size;
  460.     return 0;
  461. }
  462. int
  463. gs_setcacheupper(gs_font_dir *pdir, uint size)
  464. {    pdir->ccache.upper = size;
  465.     return 0;
  466. }
  467.  
  468. /* currentcacheparams */
  469. uint
  470. gs_currentcachesize(const gs_font_dir *pdir)
  471. {    return pdir->ccache.bmax;
  472. }
  473. uint
  474. gs_currentcachelower(const gs_font_dir *pdir)
  475. {    return pdir->ccache.lower;
  476. }
  477. uint
  478. gs_currentcacheupper(const gs_font_dir *pdir)
  479. {    return pdir->ccache.upper;
  480. }
  481.  
  482. /* Purge a font from all font- and character-related tables. */
  483. /* This is only used by restore (and, someday, the GC). */
  484. void
  485. gs_purge_font(gs_font *pfont)
  486. {    gs_font_dir *pdir = pfont->dir;
  487.     gs_font *pf;
  488.  
  489.     /* Remove the font from its list (orig_fonts or scaled_fonts). */
  490.     gs_font *prev = pfont->prev;
  491.     gs_font *next = pfont->next;
  492.     if ( next != 0 )
  493.       next->prev = prev, pfont->next = 0;
  494.     if ( prev != 0 )
  495.       prev->next = next, pfont->prev = 0;
  496.     else if ( pdir->orig_fonts == pfont )
  497.       pdir->orig_fonts = next;
  498.     else if ( pdir->scaled_fonts == pfont )
  499.       pdir->scaled_fonts = next;
  500.     else
  501.     {    /* Shouldn't happen! */
  502.         lprintf1("purged font 0x%lx not found\n", (ulong)pfont);
  503.     }
  504.  
  505.     /* Purge the font from the scaled font cache. */
  506.     for ( pf = pdir->scaled_fonts; pf != 0; )
  507.     {    if ( pf->base == pfont )
  508.         {    gs_purge_font(pf);
  509.             pf = pdir->scaled_fonts; /* start over */
  510.         }
  511.         else
  512.             pf = pf->next;
  513.     }
  514.  
  515.     /* Purge the font from the font/matrix pair cache, */
  516.     /* including all cached characters rendered with that font. */
  517.     gs_purge_font_from_char_caches(pdir, pfont);
  518.  
  519. }
  520.